reformation
Parsing via regular expressions using format syntax
Derive will require attribute reformation to specify format string,
which will be treated as format string -> regular expression string
Types implementing Reformation
by default:
- signed integers:
i8
i16
i32
i64
i128
isize
- unsigned integers:
u8
u16
u32
u64
u128
usize
- floats:
f32
f64
String
, &str
char
Option<T>
It can be used to parse:
Structs
use reformation::Reformation;
#[derive(Reformation, Debug)]
#[reformation(r"{year}-{month}-{day} {hour}:{minute}")]
struct Date{
year: u16,
month: u8,
day: u8,
hour: u8,
minute: u8,
}
fn main(){
let date = Date::parse("2018-12-22 20:23").unwrap();
assert_eq!(date.year, 2018);
assert_eq!(date.month, 12);
assert_eq!(date.day, 22);
assert_eq!(date.hour, 20);
assert_eq!(date.minute, 23);
}
Tuple Structs
use reformation::Reformation;
#[derive(Reformation)]
#[reformation(r"{} -> {}")]
struct Predicate(Empty, char);
#[derive(Reformation, Debug, PartialEq)]
#[reformation(r"Empty")]
struct Empty;
fn main(){
let p = Predicate::parse("Empty -> X").unwrap();
assert_eq!(p.0, Empty);
assert_eq!(p.1, 'X');
}
Enums
use reformation::Reformation;
#[derive(Reformation, Eq, PartialEq, Debug)]
enum Ant{
#[reformation(r"Queen\({}\)")]
Queen(String),
#[reformation(r"Worker\({}\)")]
Worker(i32),
#[reformation(r"Warrior")]
Warrior
}
fn main(){
let queen = Ant::parse("Queen(We are swarm)").unwrap();
assert_eq!(queen, Ant::Queen("We are swarm".to_string()));
let worker = Ant::parse("Worker(900000)").unwrap();
assert_eq!(worker, Ant::Worker(900000));
let warrior = Ant::parse("Warrior").unwrap();
assert_eq!(warrior, Ant::Warrior);
}
Modes
Order, in which modes are specified does not matter.
no_regex
Makes format string behave as regular string (in contrast with being regular expression),
by escaping all special regex characters.
use reformation::Reformation;
#[derive(Reformation, Debug)]
#[reformation("Vec{{{x}, {y}}}", no_regex=true)]
struct Vec{
x: i32,
y: i32,
}
fn main(){
let v= Vec::parse("Vec{-1, 1}").unwrap();
assert_eq!(v.x, -1);
assert_eq!(v.y, 1);
}
slack
Allow arbitrary number of spaces after separators: ',', ';', ':'. For separator to be recognized
as slack, it must be followed by at least one space in format string.
use reformation::Reformation;
#[derive(Reformation, Debug)]
#[reformation(r"Vec\{{{x}, {y}\}}", slack=true)]
struct Vec{
x: i32,
y: i32,
}
fn main(){
let v = Vec::parse("Vec{-1,1}").unwrap();
assert_eq!(v.x, -1);
assert_eq!(v.y, 1);
let r = Vec::parse("Vec{15, 2}").unwrap();
assert_eq!(r.x, 15);
assert_eq!(r.y, 2);
}
Combination of no_regex and slack behaves as expected:
use reformation::Reformation;
#[derive(Reformation, Debug)]
#[reformation(r"Vec({x}; {y})", slack=true, no_regex=true)]
struct Vec{
x: i32,
y: i32,
}
fn main(){
let v = Vec::parse("Vec(-1;1)").unwrap();
assert_eq!(v.x, -1);
assert_eq!(v.y, 1);
let r = Vec::parse("Vec(15; 2)").unwrap();
assert_eq!(r.x, 15);
assert_eq!(r.y, 2);
}
Extra examples
Format string behaves as regular expression, so special symbols needs to be escaped.
Also they can be used for more flexible format strings.
AVOID capture groups, since they would mess up with indexing of capture group
generated by macro. use non-capturing groups r"(?:)"
instead.
use reformation::Reformation;
#[derive(Reformation, Debug)]
#[reformation(r"Vec\{{{x},\s*{y},\s*{z}\}}")]
struct Vec{
x: f64,
y: f64,
z: f64,
}
fn main(){
let v = Vec::parse("Vec{-0.4,1e-3, 2e-3}").unwrap();
assert_eq!(v.x, -0.4);
assert_eq!(v.y, 0.001);
assert_eq!(v.z, 0.002);
}